
// /*

// 新的设计应该cmd与dat线是异步处理.
//     发送cmd时,需要判断是否接收rsp(判断是否是136位),效验rsp
//     发送dat时,需要判断send_stream是否存在数据(.vaild),存在数据则发送一个'h0,然后发送send_stream的数据(payload).并且触发send_stream.ready
//         如果fifo为空.则停止发送数据,sdio_clk被拉高,直到遇到fifo存在数据.更新数据线后,再拉低
//             如果发送数据时被cmd命令打断的时候.标记数据发送失败
//         发送完数据后,需要额外发送16位crc效验码+1个停止码. 需要等待设备busy结束(dat0,低电平表示忙碌.高电平则表示结束)
//             额外等待几个周期然后发送下一个数据块(针对多数据块处理)
//         在任何期间都可以使用cmd12停止发送多数据块

//     接收dat时,需要判断recv_stream.ready,
//         如果为高,则开启接收32位数据满后发送.vaild触发,
//         如果为低,则等待recv_stream为空,sdio_clk停止
//             假设运行时执行cmd命令,则recv_stream处理失败.直接进入数据失败.
//         多块数据传输的时候.接收完数据后,额外接收16位crc效验码+1个停止码.接着是额外的'hf,直到遇到'h0,接收下一块数据
//         多块数据传输的时候,可以使用cmd12命令停止传输


//     注1:每个数据线信号都额外处理crc16
//     注2:默认初始化总线宽度为1bit(bus), 可以通过ACMD6设置为4线模式
//     注3.

// */


// class crc8(clk:Bool,signal:Bool){
//     val en      = Reg(False)     //默认关闭
//     val crc     Bits(16 bits)
//     val u_crc = new sdio_crc8;

//     crc := u_crc.io.crc_out
//     u_crc.io.sdio_clk  := clk
//     u_crc.io.sdio_line := signal
//     u_crc.io.calc_en   := en
//     u_crc.io.crc_in    := u_crc.io.crc_out
// }


// case class sdio2() extends Component {
//     //定义IO
//     setDefinitionName("xsdio2")
//     val io = new Bundle {
//       val sdio_clk = out Bool()
//       val sdio_cmd = inout(Analog(Bits(1 bits)))
//       val sdio_dat = inout(Analog(Bits(4 bits)))

//       //命令控制
//       val mmc_init     = in Bool()
//       val sdio_cmd_en   = in Bool()
//       val sdio_cmd_valu = in UInt(6 bits)
//       val sdio_cmd_argu = in UInt(32 bits)
//       val sdio_cmd_need_rsp = in Bool()
//       val sdio_cmd_long_rsp = in Bool()
//       val sdio_rsp      = out Bits(256 bits)
//       val sdio_bus_4bit = in Bool()     //默认1bit

//       //分频器
//       val sdio_clkdiv   = in SInt(8 bits)

//       ///////////////////////////////////////////////////////////
//       val dat_next_en       = in Bool()                 //开启下一个数据处理,用于多块处理,如果是sdio_dat_write开启,则进入写入状态
//       //数据控制
//       val block_size        = in SInt(16 bits)          //最大支持32KByte块传输,实际上默认为512字节
//       val sdio_dat_en       = in Bool()
//       val sdio_dat_write    = in Bool()

//       //////////////////////////////////////////////////////
//       //数据接收处理
//       val sdio_recv_dat     = out Bits(32 bits)
//       val sdio_recv_dat_wr  = out Bool()
//       //使用Stream来传输,
//       val recv_stream       = master Stream(Bits(32 bits))
//       val send_stream       = slave  Stream(Bits(32 bits))
//       /////////////////////////////////////////////////////////////

//       //时钟处理
//       val timeout_tick      = in UInt(32 bits)
//       val timeout_reset     = in Bool()

//       //状态输出
//       val busy              = out Bool()
//       val cmd_send_done     = out Bool()
//       val crc_rsp_ok        = out Bool()
//       val crc_dat_ok        = out Bool()
//       val crc_rsp_fail      = out Bool()
//       val crc_dat_fail      = out Bool()
//       val timeout           = out Bool()
//       val timeout_rsp       = out Bool()
//       val timeout_dat       = out Bool()
//       val dat_end           = out Bool()
//     }

//     var clk_cnt = Reg(U"32d0")
//     when(clk_cnt>io.sdio_clkdiv){
//         clk_cnt := 0;
//     }.otherwise{
//         clk_cnt := clk_cnt + 1
//     }


//     val transmit = Reg(False)

//     //
//     val sdio_clk = Reg(Bool()) init(True)
//     sdio_clk.riseWhen(~sdio_clk && clk_cnt>=io.sdio_clkdiv)                                    //只要是低电平,则被拉高,执行一次传输
//     sdio_clk.fallWhen(transmit  && clk_cnt>=io.sdio_clkdiv)                                     //执行一次传输

//     val crc_cmd         = crc8(sdio_clk,io.sdio_cmd)
//     val cmd_seq         = B"01" ## io.sdio_cmd_valu ## io.sdio_cmd_argu ## B"xFF"
//     val cmd_remaining   = Reg(SInt) init(0)
//     val rsp_remaining   = Reg(SInt) init(0)
//     val rsp             = Reg(Bits(256 bits)) init(0)
//     val cmd_oe          = Bool
//     val dat_oe          = Reg(False)
//     val cmd_o           = Reg(True)
//     val cmd_dat         = Reg(Bits(48 bits)) init(0)
//     val wait_rsp        = Reg(False)
//     val dat             = Reg(Bits(4 bits)) init(0)
//     when(cmd_oe) {
//         io.sdio_cmd := cmd_o
//     }

//     when(dat_oe) {
//         io.sdio_dat := dat
//     }

//     /*
//     信号说明
// transmit:_______^^^^^^^^^
// cmd     :-------ooooooooo
// send_dat:-------------oooooo.......
// s_valid :_____________^^^^^^.......
// dat     :--------------0oooo.......
// s_len   :--------------887766554433
// clk     :^^^^^^^^^^^^^^_^_^_^_^_^_^
// crc     :---------------u-u-u               u为更新
//     */

//     cmd_oe := cmd_remaining>0

//     ////////////////////////////////////////////////////////
//     //处理命令,边沿更新数据
//     when(io.sdio_cmd_en.rise) {
//         //开始传输数据
//         transmit        := True
//         cmd_remaining   :  48
//         wait_rsp        := io.sdio_cmd_need_rsp;
//         rsp_remaining   := Mux(
//             io.sdio_cmd_need_rsp,
//                 Mux(io.sdio_cmd_long_rsp,S"d138",S"d48"),
//             0
//         )
//         cmd_dat         := cmd_seq
//     }
//     .elsewhen(sdio_clk.rise){
//         when(cmd_remaining>0) {
//             //发送命令
//             cmd_o       :=  cmd_dat(47)
//             cmd_dat     :=  (cmd_dat |<< 1) | B"1"
//             cmd_remaining := cmd_remaining - 1
//         }
//         .elsewhen(wait_rsp) {
//             when(!io.sdio_cmd) {
//                 wait_rsp := False
//             }
//         }
//         .elsewhen(rsp_remaining>0) {
//             //位移rsp
//             rsp         := (rsp |<< 1) | io.sdio_cmd
//         }
//     }
//     /////////////////////////////////////////////////////////
//     //处理数据,接收数据
//     val wait_dat = Reg(False)
//     val wait_dat_end = ~io.sdio_dat(0)
//     val recv_data = Reg(Bits(32+4 Bits)) init(0)
//     val recv_data_wr = (recv_data(32))
//     val dat_crc_calc_en = Reg(False)
//     io.recv_stream.vaild        := recv_data_wr.rise
//     io.recv_stream.payload      := recv_data(31 downto 0)

//     when(sdio_clk.fall){        //应该是下降沿的时候获得数据
//         when(wait_dat){
//             //等待数据开始
//             when(wait_dat_end){
//                 //等待结束
//                 wait_dat            := False
//                 recv_data           := 1            //作为触发
//                 dat_crc_calc_en     := True
//             }
//         }
//         .elsewhen(io.recv_stream.ready) {
//             //可接收数据
//             when(io.sdio_bus_4bit){
//                 recv_data   := (recv_data |<<4) | io.sdio_dat
//             }.otherwise {
//                 recv_data   := (recv_data |<<1) | io.sdio_dat(0)
//             }
//         }
//         .otherwise{
//             //不可接收数据
//             transmit := False
//         }
//     }

//     //处理数据,发送数据
//     val send_len = Reg(SInt) init(0)
//     val send_dat = Reg(Bits(32 bits)) init(0)

//     when(send_len>0){
//     }
//     .elsewhen(send_dat.vaild){
//         //数据有效
//         send_len := 8;
//         send_dat := send_stream.payload

//     }

//     /////////////////////////////////////////////////////////






// }
